const db = require('../../MySql'); // 引入数据库连接
const { formatDateTime } = require('../utils/dateUtils')
const crypto = require('crypto');
/**
 * 系统用户模型类
 * 对应数据库中的 sys_user 表
 * 实现用户数据的面向对象封装
 */
class sys_user {
    /**
     * 构造函数 - 创建用户对象实例
     * @param {string} id - 用户ID
     * @param {string} user_name - 用户名
     * @param {string} real_name - 真实姓名
     * @param {string} password - 密码（加密后）
     * @param {string} salt - 密码盐值
     * @param {string} role_ids - 角色ID列表（多个角色用逗号分隔）
     * @param {string} depart_id - 部门ID
     * @param {string} create_time - 创建时间
     * @param {string} update_time - 更新时间
     * @param {number} state - 在线状态（0-离线，1-在线）
     * @param {number} data_flag - 账户状态（0-正常，1-禁用）
     * @param {string} last_active_time - 最后活跃时间
     */
    constructor(id, user_name, real_name, password, salt, role_ids, depart_id, create_time, update_time, state, data_flag, last_active_time) {
        this.id = id;
        this.userName = user_name;
        this.realName = real_name;
        this.password = password;
        this.salt = salt;
        this.roleIds = role_ids;
        this.departId = depart_id;
        this.createTime = create_time;
        this.updateTime = update_time;
        this.state = state;
        this.dataFlag = data_flag;
        this.last_active_time = last_active_time;
    }

    /**
     * 静态方法 - 查询用户列表
     * 查询所有用户数据并返回用户对象数组
     * @returns {Promise<sys_user[]>} 用户对象数组的Promise
     * @throws {Error} 数据库查询错误
     */
    static async findPaging(params = {}) {
        const { realName = '', userName = '' } = params || {}
        let sql = `select * from sys_user `
        let conditions = []

        if (realName) {
            conditions.push(`real_name like '%${realName}%'`)
        }
        if (userName) {
            conditions.push(`user_name like '%${userName}%'`)
        }

        if (conditions.length > 0) {
            sql += ` where ` + conditions.join(' and ')
        }

        sql += ` order by id desc`

        // 执行SQL查询，获取所有用户数据
        const [results] = await db.query(sql)

        // 将查询结果映射为sys_user对象实例
        return results.map(item => new sys_user(
            item.id,
            item.user_name,
            item.real_name,
            item.password,
            item.salt,
            item.role_ids,
            item.depart_id,
            formatDateTime(item.create_time),
            formatDateTime(item.update_time),
            item.state,
            item.data_flag,
            formatDateTime(item.last_active_time)
        ))
    }

    //获取用户盐值
    static async getSalt(username) {
        const [results] = await db.query('SELECT salt FROM sys_user WHERE user_name = ?', [username])
        return results[0].salt
    }

    //根据用户名和加密后的密码查询用户信息
    static async findUserByUsernameAndPassword(username, encryptedPwd) {
        const [results] = await db.query('SELECT * FROM sys_user WHERE user_name = ? AND password = ?', [username, encryptedPwd])
        return results[0]
    }

    //根据用户名查询用户
    static async findUserByUsername(username) {
        const [results] = await db.query('SELECT * FROM sys_user WHERE user_name = ?', [username])
        return results[0]
    }

    //根据用户ID查询用户信息
    static async findUserById(userId) {
        const [results] = await db.query('SELECT * FROM sys_user WHERE id = ?', [userId])
        return results[0]
    }

    //更新用户在线状态
    static async updateUserState(userId, state) {
        // 执行SQL更新操作，更新用户状态
        const [results] = await db.query('UPDATE sys_user SET state = ? WHERE id = ?', [state, userId])
        return results.affectedRows > 0
    }

    //更新密码
    static async updatePassword(user_name, newPassword) {
        //查询盐值
        const salt = await sys_user.getSalt(user_name)

        //md5加密密码
        const encryptedPwd = crypto.createHash('md5').update(newPassword + salt).digest('hex')

        // 执行SQL更新操作，更新密码
        const [results] = await db.query('UPDATE sys_user SET password = ? WHERE user_name = ?', [encryptedPwd, user_name])
        return results.affectedRows > 0
    }

    //更新用户账号状态，0-启用，1-禁用
    static async updateUserDataFlag(userId, dataFlag) {
        // 执行SQL更新操作，更新用户数据标志
        const [results] = await db.query('UPDATE sys_user SET data_flag = ? WHERE id = ?', [dataFlag, userId])
        return results.affectedRows > 0
    }

    //更新用户最后活跃时间
    static async updateLastActiveTime(userId, lastActiveTime) {
        // 执行SQL更新操作，更新用户最后活跃时间
        const [results] = await db.query('UPDATE sys_user SET last_active_time = ? WHERE id = ?', [lastActiveTime, userId])
        return results.affectedRows > 0
    }

    //更新用户信息
    static async updateUser(userId, updateData) {
        // 构建更新字段和参数
        const updateFields = []
        const updateParams = []

        // 检查并添加可更新字段
        if (updateData.user_name !== undefined) {
            updateFields.push('user_name = ?');
            updateParams.push(updateData.user_name);
        }
        if (updateData.real_name !== undefined) {
            updateFields.push('real_name = ?');
            updateParams.push(updateData.real_name);
        }
        if (updateData.role_ids !== undefined) {
            updateFields.push('role_ids = ?');
            updateParams.push(updateData.role_ids);
        }
        if (updateData.depart_id !== undefined) {
            updateFields.push('depart_id = ?');
            updateParams.push(updateData.depart_id);
        }
        if (updateData.data_flag !== undefined) {
            updateFields.push('data_flag = ?');
            updateParams.push(updateData.data_flag);
        }
        if (updateData.last_active_time !== undefined) {
            updateFields.push('last_active_time = ?');
            updateParams.push(updateData.last_active_time);
        }

        // 总是更新update_time
        updateFields.push('update_time = NOW()');

        // 如果没有可更新的字段，直接返回
        if (updateFields.length === 0) {
            return false;
        }

        // 构建SQL语句
        const sql = `UPDATE sys_user SET ${updateFields.join(', ')} WHERE id = ?`;
        updateParams.push(userId);

        // 执行更新操作
        const [results] = await db.query(sql, updateParams);
        return results.affectedRows > 0;
    }

    //根据用户ID删除用户
    static async deleteUserById(userId) {
        // 执行SQL删除操作，根据用户ID删除用户
        const [results] = await db.query('DELETE FROM sys_user WHERE id = ?', [userId])
        return results.affectedRows > 0
    }

    //获取用户总数
    static async countUser(){
        const [results]=await db.query('select count(*) from sys_user')
        return results[0]['count(*)']
    }

    //注册时插入用户数据
    static async insertUser(userData) {
        const { id, user_name, real_name, password, salt, role_ids, create_time, update_time, state, data_flag, last_active_time } = userData;
        const [results] = await db.query('INSERT INTO sys_user (id, user_name, real_name, password, salt, role_ids, create_time, update_time, state, data_flag, last_active_time) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', [id, user_name, real_name, password, salt, role_ids, create_time, update_time, state, data_flag, last_active_time]);
        return results.affectedRows > 0;
    }

    // 角色映射函数 - 将中文角色名转换为英文标识
    static async mapRoleNameToId(roleName) {
    const roleMap = {
        '学生': 'student',
        '教师': 'teacher'
    };
    
    // 如果角色名在映射表中，返回对应的英文标识，否则默认为学生
    return roleMap[roleName] || 'null';
    }
}

module.exports = sys_user;